SGI Freeware 1999 August/SGI Freeware 1999 August.iso/dist/fw_perl.idb/usr/freeware/catman/u_man/cat1/perlfaq7.Z/perlfaq7

Text File | 1998-10-28 | 44.3 KB | 1,189 lines

     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



     NNNNAAAAMMMMEEEE
      perlfaq7 - Perl Language Issues ($Revision: 1.21 $, $Date:
      1998/06/22 15:20:07 $)

     DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
      This section deals with general Perl language    issues that
      don't    clearly    fit into any of    the other sections.

      CCCCaaaannnn IIII    ggggeeeetttt aaaa BBBBNNNNFFFF////yyyyaaaacccccccc////RRRREEEE ffffoooorrrr tttthhhheeee PPPPeeeerrrrllll llllaaaannnngggguuuuaaaaggggeeee????

      There    is no BNF, but you can paw your    way through the    yacc
      grammar in perly.y in    the source distribution    if you're
      particularly brave.  The grammar relies on very smart
      tokenizing code, so be prepared to venture into toke.c as
      well.

      In the words of Chaim    Frenkel: "Perl's grammar can not be
      reduced to BNF.  The work of parsing perl is distributed
      between yacc,    the lexer, smoke and mirrors."

      WWWWhhhhaaaatttt aaaarrrreeee aaaallllllll tttthhhheeeesssseeee $$$$@@@@%%%%**** ppppuuuunnnnccccttttuuuuaaaattttiiiioooonnnn ssssiiiiggggnnnnssss,,,, aaaannnndddd hhhhoooowwww ddddoooo    IIII kkkknnnnoooowwww
      wwwwhhhheeeennnn ttttoooo uuuusssseeee tttthhhheeeemmmm????

      They are type    specifiers, as detailed    in the _p_e_r_l_d_a_t_a
      manpage:

          $    for scalar values (number, string or reference)
          @    for arrays
          %    for hashes (associative    arrays)
          *    for all    types of that symbol name.  In version 4 you used them like
        pointers, but in modern    perls you can just use references.

      While    there are a few    places where you don't actually    need
      these    type specifiers, you should always use them.

      A couple of others that you're likely    to encounter that
      aren't really    type specifiers    are:

          <> are used for inputting    a record from a    filehandle.
          \     takes a reference to something.

      Note that <FILE> is _n_e_i_t_h_e_r the type specifier for files nor
      the name of the handle.  It is the <>    operator applied to
      the handle FILE.  It reads one line (well, record - see the
      section on $/    in the _p_e_r_l_v_a_r manpage)    from the handle    FILE
      in scalar context, or    _a_l_l lines in list context.  When
      performing open, close, or any other operation besides <> on
      files, or even talking about the handle, do _n_o_t use the
      brackets.  These are correct:    eof(FH), seek(FH, 0, 2)    and
      "copying from    STDIN to FILE".





     Page 1                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      DDDDoooo IIII aaaallllwwwwaaaayyyyssss////nnnneeeevvvveeeerrrr hhhhaaaavvvveeee ttttoooo qqqquuuuooootttteeee mmmmyyyy ssssttttrrrriiiinnnnggggssss oooorrrr    uuuusssseeee sssseeeemmmmiiiiccccoooolllloooonnnnssss
      aaaannnndddd ccccoooommmmmmmmaaaassss????

      Normally, a bareword doesn't need to be quoted, but in most
      cases    probably should    be (and    must be    under use strict).
      But a    hash key consisting of a simple    word (that isn't the
      name of a defined subroutine)    and the    left-hand operand to
      the => operator both count as    though they were quoted:

          This              is like this
          ------------          ---------------
          $foo{line}          $foo{"line"}
          bar => stuff          "bar" => stuff

      The final semicolon in a block is optional, as is the    final
      comma    in a list.  Good style (see the    _p_e_r_l_s_t_y_l_e manpage)
      says to put them in except for one-liners:

          if ($whoops) { exit 1 }
          @nums = (1, 2, 3);

          if ($whoops) {
          exit 1;
          }
          @lines = (
          "There Beren came from mountains cold",
          "And lost he wandered    under leaves",
          );


      HHHHoooowwww ddddoooo IIII sssskkkkiiiipppp    ssssoooommmmeeee rrrreeeettttuuuurrrrnnnn vvvvaaaalllluuuueeeessss????

      One way is to    treat the return values    as a list and index
      into it:

          $dir = (getpwnam($user))[7];

      Another way is to use    undef as an element on the left-hand-
      side:

          ($dev, $ino, undef, undef, $uid, $gid) = stat($file);


      HHHHoooowwww ddddoooo IIII tttteeeemmmmppppoooorrrraaaarrrriiiillllyyyy bbbblllloooocccckkkk wwwwaaaarrrrnnnniiiinnnnggggssss????

      The $^W variable (documented in the _p_e_r_l_v_a_r manpage)
      controls runtime warnings for    a block:

          {
          local    $^W = 0;    # temporarily turn off warnings
          $a = $b + $c;        # I know these might be    undef
          }



     Page 2                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      Note that like all the punctuation variables,    you cannot
      currently use    _m_y() on    $^W, only _l_o_c_a_l().

      A new    use warnings pragma is in the works to provide finer
      control over all this.  The curious should check the perl5-
      porters mailing list archives    for details.

      WWWWhhhhaaaatttt''''ssss aaaannnn eeeexxxxtttteeeennnnssssiiiioooonnnn????

      A way    of calling compiled C code from    Perl.  Reading the
      _p_e_r_l_x_s_t_u_t manpage is a good place to learn more about
      extensions.

      WWWWhhhhyyyy ddddoooo PPPPeeeerrrrllll ooooppppeeeerrrraaaattttoooorrrrssss    hhhhaaaavvvveeee ddddiiiiffffffffeeeerrrreeeennnntttt pppprrrreeeecccceeeeddddeeeennnncccceeee tttthhhhaaaannnn CCCC
      ooooppppeeeerrrraaaattttoooorrrrssss????

      Actually, they don't.     All C operators that Perl copies have
      the same precedence in Perl as they do in C.    The problem is
      with operators that C    doesn't    have, especially functions
      that give a list context to everything on their right, eg
      print, chmod,    exec, and so on.  Such functions are called
      "list    operators" and appear as such in the precedence    table
      in the _p_e_r_l_o_p    manpage.

      A common mistake is to write:

          unlink $file || die "snafu";

      This gets interpreted    as:

          unlink ($file || die "snafu");

      To avoid this    problem, either    put in extra parentheses or
      use the super    low precedence or operator:

          (unlink $file) ||    die "snafu";
          unlink $file or die "snafu";

      The "English"    operators (and,    or, xor, and not) deliberately
      have precedence lower    than that of list operators for    just
      such situations as the one above.

      Another operator with    surprising precedence is
      exponentiation.  It binds more tightly even than unary
      minus, making    -2**2 product a    negative not a positive    four.
      It is    also right-associating,    meaning    that 2**3**2 is    two
      raised to the    ninth power, not eight squared.

      Although it has the same precedence as in C, Perl's ?:
      operator produces an lvalue.    This assigns $x    to either $a
      or $b, depending on the trueness of $maybe:




     Page 3                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



          ($maybe ?    $a : $b) = $x;


      HHHHoooowwww ddddoooo IIII ddddeeeeccccllllaaaarrrreeee////ccccrrrreeeeaaaatttteeee aaaa ssssttttrrrruuuuccccttttuuuurrrreeee????

      In general, you don't    "declare" a structure.    Just use a
      (probably anonymous) hash reference.    See the    _p_e_r_l_r_e_f
      manpage and the _p_e_r_l_d_s_c manpage for details.    Here's an
      example:

          $person =    {};              #    new anonymous hash
          $person->{AGE}  =    24;          #    set field AGE to 24
          $person->{NAME} =    "Nat";          #    set field NAME to "Nat"

      If you're looking for    something a bit    more rigorous, try the
      _p_e_r_l_t_o_o_t manpage.

      HHHHoooowwww ddddoooo IIII ccccrrrreeeeaaaatttteeee aaaa mmmmoooodddduuuulllleeee????

      A module is a    package    that lives in a    file of    the same name.
      For example, the Hello::There    module would live in
      Hello/There.pm.  For details,    read the _p_e_r_l_m_o_d manpage.
      You'll also find the _E_x_p_o_r_t_e_r    manpage    helpful.  If you're
      writing a C or mixed-language    module with both C and Perl,
      then you should study    the _p_e_r_l_x_s_t_u_t manpage.

      Here's a convenient template you might wish you use when
      starting your    own module.  Make sure to change the names
      appropriately.

          package Some::Module;  # assumes Some/Module.pm

          use strict;

          BEGIN {
          use Exporter     ();
          use vars     qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);

          ## set the version for version checking; uncomment to    use
          ## $VERSION      = 1.00;

          # if using RCS/CVS, this next    line may be preferred,
          # but    beware two-digit versions.
          $VERSION = do{my@r=q$Revision: 1.21 $=~/\d+/g;sprintf    '%d.'.'%02d'x$#r,@r};

          @ISA           = qw(Exporter);
          @EXPORT      = qw(&func1 &func2 &func3);
          %EXPORT_TAGS = ( );      # eg:    TAG => [ qw!name1 name2! ],







     Page 4                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



          # your exported package globals go here,
          # as well as any optionally exported functions
          @EXPORT_OK   = qw($Var1 %Hashit);
          }
          use vars        @EXPORT_OK;

          #    non-exported package globals go    here
          use vars        qw(    @more $stuff );

          #    initialize package globals, first exported ones
          $Var1   =    '';
          %Hashit =    ();

          #    then the others    (which are still accessible as $Some::Module::stuff)
          $stuff  =    '';
          @more   =    ();

          #    all file-scoped    lexicals must be created before
          #    the functions below that use them.

          #    file-private lexicals go here
          my $priv_var    =    '';
          my %secret_hash =    ();

          #    here's a file-private function as a closure,
          #    callable as &$priv_func;  it cannot be prototyped.
          my $priv_func = sub {
          # stuff goes here.
          };

          #    make all your functions, whether exported or not;
          #    remember to put    something interesting in the {}    stubs
          sub func1         {}       # no    prototype
          sub func2()    {}       # proto'd void
          sub func3($$)  {}       # proto'd to    2 scalars

          #    this one isn't exported, but could be called!
          sub func4(\%)  {}       # proto'd to    1 hash ref

          END { }        # module clean-up code here    (global    destructor)

          1;        # modules must return true


      HHHHoooowwww ddddoooo IIII ccccrrrreeeeaaaatttteeee aaaa ccccllllaaaassssssss????

      See the _p_e_r_l_t_o_o_t manpage for an introduction to classes and
      objects, as well as the _p_e_r_l_o_b_j manpage and the _p_e_r_l_b_o_t
      manpage.






     Page 5                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      HHHHoooowwww ccccaaaannnn IIII tttteeeellllllll iiiiffff aaaa vvvvaaaarrrriiiiaaaabbbblllleeee iiiissss ttttaaaaiiiinnnntttteeeedddd????

      See the section on _L_a_u_n_d_e_r_i_n_g    _a_n_d _D_e_t_e_c_t_i_n_g _T_a_i_n_t_e_d _D_a_t_a in
      the _p_e_r_l_s_e_c manpage.    Here's an example (which doesn't use
      any system calls, because the    _k_i_l_l() is given    no processes
      to signal):

          sub is_tainted {
          return ! eval    { join('',@_), kill 0; 1; };
          }

      This is not -w clean,    however.  There    is no -w clean way to
      detect taintedness - take this as a hint that    you should
      untaint all possibly-tainted data.

      WWWWhhhhaaaatttt''''ssss aaaa cccclllloooossssuuuurrrreeee????

      Closures are documented in the _p_e_r_l_r_e_f manpage.

      _C_l_o_s_u_r_e is a computer    science    term with a precise but    hard-
      to-explain meaning. Closures are implemented in Perl as
      anonymous subroutines    with lasting references    to lexical
      variables outside their own scopes.  These lexicals
      magically refer to the variables that    were around when the
      subroutine was defined (deep binding).

      Closures make    sense in any programming language where    you
      can have the return value of a function be itself a
      function, as you can in Perl.     Note that some    languages
      provide anonymous functions but are not capable of providing
      proper closures; the Python language,    for example.  For more
      information on closures, check out any textbook on
      functional programming.  Scheme is a language    that not only
      supports but encourages closures.

      Here's a classic function-generating function:

          sub add_function_generator {
        return sub { shift + shift };
          }

          $add_sub = add_function_generator();
          $sum = $add_sub->(4,5);             # $sum is 9 now.

      The closure works as a _f_u_n_c_t_i_o_n _t_e_m_p_l_a_t_e with    some
      customization    slots left out to be filled later.  The
      anonymous subroutine returned    by _a_d_d__f_u_n_c_t_i_o_n__g_e_n_e_r_a_t_o_r()
      isn't    technically a closure because it refers    to no lexicals
      outside its own scope.

      Contrast this    with the following _m_a_k_e__a_d_d_e_r()    function, in
      which    the returned anonymous function    contains a reference



     Page 6                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      to a lexical variable    outside    the scope of that function
      itself.  Such    a reference requires that Perl return a    proper
      closure, thus    locking    in for all time    the value that the
      lexical had when the function    was created.

          sub make_adder {
          my $addpiece = shift;
          return sub { shift + $addpiece };
          }

          $f1 = make_adder(20);
          $f2 = make_adder(555);

      Now &$f1($n) is always 20 plus whatever $n you pass in,
      whereas &$f2($n) is always 555 plus whatever $n you pass in.
      The $addpiece    in the closure sticks around.

      Closures are often used for less esoteric purposes.  For
      example, when    you want to pass in a bit of code into a
      function:

          my $line;
          timeout( 30, sub { $line = <STDIN> } );

      If the code to execute had been passed in as a string,
      '$line = <STDIN>', there would have been no way for the
      hypothetical _t_i_m_e_o_u_t() function to access the    lexical
      variable $line back in its caller's scope.

      WWWWhhhhaaaatttt iiiissss vvvvaaaarrrriiiiaaaabbbblllleeee ssssuuuuiiiicccciiiiddddeeee aaaannnndddd hhhhoooowwww ccccaaaannnn IIII pppprrrreeeevvvveeeennnntttt iiiitttt????

      Variable suicide is when you (temporarily or permanently)
      lose the value of a variable.     It is caused by scoping
      through _m_y() and _l_o_c_a_l() interacting with either closures or
      aliased _f_o_r_e_a_c_h() interator variables    and subroutine
      arguments.  It used to be easy to inadvertently lose a
      variable's value this    way, but now it's much harder.    Take
      this code:

          my $f = "foo";
          sub T {
        while ($i++ < 3) { my $f = $f; $f .= "bar"; print $f, "\n" }
          }
          T;
          print "Finally $f\n";

      The $f that has "bar"    added to it three times    should be a
      new $f (my $f    should create a    new local variable each    time
      through the loop).  It isn't,    however.  This is a bug, and
      will be fixed.





     Page 7                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      HHHHoooowwww ccccaaaannnn IIII ppppaaaassssssss////rrrreeeettttuuuurrrrnnnn    aaaa {{{{FFFFuuuunnnnccccttttiiiioooonnnn,,,, FFFFiiiilllleeeeHHHHaaaannnnddddlllleeee,,,, AAAArrrrrrrraaaayyyy,,,,    HHHHaaaasssshhhh,,,,
      MMMMeeeetttthhhhoooodddd,,,, RRRReeeeggggeeeexxxxpppp}}}}????

      With the exception of    regexps, you need to pass references
      to these objects.  See the section on    _P_a_s_s _b_y    _R_e_f_e_r_e_n_c_e in
      the _p_e_r_l_s_u_b manpage for this particular question, and    the
      _p_e_r_l_r_e_f manpage for information on references.

      Passing Variables and    Functions
          Regular variables    and functions are quite    easy: just
          pass in a    reference to an    existing or anonymous variable
          or function:

          func(    \$some_scalar );

          func(    \$some_array  );
          func(    [ 1 .. 10 ]   );

          func(    \%some_hash   );
          func(    { this => 10, that => 20 }   );

          func(    \&some_func   );
          func(    sub { $_[0] ** $_[1] }     );


      Passing Filehandles
          To pass filehandles to subroutines, use the *FH or \*FH
          notations.  These    are "typeglobs"    - see the section on
          _T_y_p_e_g_l_o_b_s    _a_n_d _F_i_l_e_h_a_n_d_l_e_s    in the _p_e_r_l_d_a_t_a    manpage    and
          especially the section on    _P_a_s_s _b_y    _R_e_f_e_r_e_n_c_e in the
          _p_e_r_l_s_u_b manpage for more information.

          Here's an    excerpt:

          If you're    passing    around filehandles, you    could usually
          just use the bare    typeglob, like *STDOUT,    but typeglobs
          references would be better because they'll still work
          properly under use strict    'refs'.     For example:

          splutter(\*STDOUT);
          sub splutter {
              my $fh = shift;
              print $fh    "her um    well a hmmm\n";
          }

          $rec = get_rec(\*STDIN);
          sub get_rec {
              my $fh = shift;
              return scalar <$fh>;
          }

          If you're    planning on generating new filehandles,    you



     Page 8                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



          could do this:

          sub openit {
              my $name = shift;
              local *FH;
              return open (FH, $path) ?    *FH : undef;
          }
          $fh =    openit('< /etc/motd');
          print    <$fh>;


      Passing Regexps
          To pass regexps around, you'll need to either use    one of
          the highly experimental regular expression modules from
          CPAN (Nick Ing-Simmons's Regexp or Ilya Zakharevich's
          Devel::Regexp), pass around strings and use an
          exception-trapping eval, or else be be very, very
          clever.  Here's an example of how    to pass    in a string to
          be regexp    compared:

          sub compare($$) {
              my ($val1, $regexp) = @_;
              my $retval = eval    { $val =~ /$regexp/ };
              die if $@;
              return $retval;
          }

          $match = compare("old    McDonald", q/d.*D/);

          Make sure    you never say something    like this:

          return eval "\$val =~    /$regexp/";   #    WRONG

          or someone can sneak shell escapes into the regexp due
          to the double interpolation of the eval and the double-
          quoted string.  For example:

          $pattern_of_evil = 'danger ${    system("rm -rf * &") } danger';

          eval "\$string =~ /$pattern_of_evil/";

          Those preferring to be very, very    clever might see the
          O'Reilly book, _M_a_s_t_e_r_i_n_g _R_e_g_u_l_a_r _E_x_p_r_e_s_s_i_o_n_s, by Jeffrey
          Friedl.  Page 273's _B_u_i_l_d__M_a_t_c_h_M_a_n_y__F_u_n_c_t_i_o_n() is
          particularly interesting.     A complete citation of    this
          book is given in the _p_e_r_l_f_a_q_2 manpage.

      Passing Methods
          To pass an object    method into a subroutine, you can do
          this:





     Page 9                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



          call_a_lot(10, $some_obj, "methname")
          sub call_a_lot {
              my ($count, $widget, $trick) = @_;
              for (my $i = 0; $i < $count; $i++) {
              $widget->$trick();
              }
          }

          Or you can use a closure to bundle up the    object and its
          method call and arguments:

          my $whatnot =     sub { $some_obj->obfuscate(@args) };
          func($whatnot);
          sub func {
              my $code = shift;
              &$code();
          }

          You could    also investigate the _c_a_n() method in the
          UNIVERSAL    class (part of the standard perl
          distribution).

      HHHHoooowwww ddddoooo IIII ccccrrrreeeeaaaatttteeee aaaa ssssttttaaaattttiiiicccc vvvvaaaarrrriiiiaaaabbbblllleeee????

      As with most things in Perl, TMTOWTDI.  What is a "static
      variable" in other languages could be    either a function-
      private variable (visible only within    a single function,
      retaining its    value between calls to that function), or a
      file-private variable    (visible only to functions within the
      file it was declared in) in Perl.

      Here's code to implement a function-private variable:

          BEGIN {
          my $counter =    42;
          sub prev_counter { return --$counter }
          sub next_counter { return $counter++ }
          }

      Now _p_r_e_v__c_o_u_n_t_e_r() and _n_e_x_t__c_o_u_n_t_e_r()    share a    private
      variable $counter that was initialized at compile time.

      To declare a file-private variable, you'll still use a _m_y(),
      putting it at    the outer scope    level at the top of the    file.
      Assume this is in file Pax.pm:

          package Pax;
          my $started = scalar(localtime(time()));

          sub begun    { return $started }

      When use Pax or require Pax loads this module, the variable



     Page 10                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      will be initialized.    It won't get garbage-collected the way
      most variables going out of scope do,    because    the _b_e_g_u_n()
      function cares about it, but no one else can get it.    It is
      not called $Pax::started because its scope is    unrelated to
      the package.    It's scoped to the file.  You could
      conceivably have several packages in that same file all
      accessing the    same private variable, but another file    with
      the same package couldn't get    to it.

      See the section on _P_e_r_i_s_t_e_n_t _P_r_i_v_a_t_e _V_a_r_i_a_b_l_e_s in the
      _p_e_r_l_s_u_b manpage for details.

      WWWWhhhhaaaatttt''''ssss tttthhhheeee ddddiiiiffffffffeeeerrrreeeennnncccceeee    bbbbeeeettttwwwweeeeeeeennnn    ddddyyyynnnnaaaammmmiiiicccc    aaaannnndddd lllleeeexxxxiiiiccccaaaallll ((((ssssttttaaaattttiiiicccc))))
      ssssccccooooppppiiiinnnngggg????  BBBBeeeettttwwwweeeeeeeennnn _l_o_c_a_l() and    _m_y()?

      local($x) saves away the old value of    the global variable
      $x, and assigns a new    value for the duration of the
      subroutine, _w_h_i_c_h _i_s _v_i_s_i_b_l_e _i_n _o_t_h_e_r    _f_u_n_c_t_i_o_n_s _c_a_l_l_e_d _f_r_o_m
      _t_h_a_t _s_u_b_r_o_u_t_i_n_e.  This is done at run-time, so is called
      dynamic scoping.  _l_o_c_a_l() always affects global variables,
      also called package variables    or dynamic variables.

      my($x) creates a new variable    that is    only visible in    the
      current subroutine.  This is done at compile-time, so    is
      called lexical or static scoping.  _m_y() always affects
      private variables, also called lexical variables or
      (improperly) _s_t_a_t_i_c(ly scoped) variables.

      For instance:

          sub visible {
          print    "var has value $var\n";
          }

          sub dynamic {
          local    $var = 'local';      # new    temporary value    for the    still-global
          visible();          #   variable called $var
          }

          sub lexical {
          my $var = 'private';      # new    private    variable, $var
          visible();          # (invisible outside of sub scope)
          }

          $var = 'global';

          visible();          # prints global
          dynamic();          # prints local
          lexical();          # prints global

      Notice how at    no point does the value    "private" get printed.
      That's because $var only has that value within the block of



     Page 11                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      the _l_e_x_i_c_a_l()    function, and it is hidden from    called
      subroutine.

      In summary, _l_o_c_a_l() doesn't make what    you think of as
      private, local variables.  It    gives a    global variable    a
      temporary value.  _m_y() is what you're    looking    for if you
      want private variables.

      See the section on _P_r_i_v_a_t_e _V_a_r_i_a_b_l_e_s _v_i_a _m_y()    in the _p_e_r_l_s_u_b
      manpage and the section on _T_e_m_p_o_r_a_r_y _V_a_l_u_e_s _v_i_a _l_o_c_a_l() in
      the _p_e_r_l_s_u_b manpage for excruciating details.

      HHHHoooowwww ccccaaaannnn IIII aaaacccccccceeeessssssss aaaa ddddyyyynnnnaaaammmmiiiicccc vvvvaaaarrrriiiiaaaabbbblllleeee wwwwhhhhiiiilllleeee aaaa ssssiiiimmmmiiiillllaaaarrrrllllyyyy    nnnnaaaammmmeeeedddd
      lllleeeexxxxiiiiccccaaaallll iiiissss iiiinnnn    ssssccccooooppppeeee????

      You can do this via symbolic references, provided you
      haven't set use strict "refs".  So instead of    $var, use
      ${'var'}.

          local $var = "global";
          my    $var = "lexical";

          print "lexical is    $var\n";

          no strict    'refs';
          print "global  is    ${'var'}\n";

      If you know your package, you    can just mention it
      explicitly, as in $Some_Pack::var.  Note that    the notation
      $::var is _n_o_t    the dynamic $var in the    current    package, but
      rather the one in the    main package, as though    you had
      written $main::var.  Specifying the package directly makes
      you hard-code    its name, but it executes faster and avoids
      running afoul    of use strict "refs".

      WWWWhhhhaaaatttt''''ssss tttthhhheeee ddddiiiiffffffffeeeerrrreeeennnncccceeee    bbbbeeeettttwwwweeeeeeeennnn    ddddeeeeeeeepppp aaaannnndddd sssshhhhaaaalllllllloooowwww bbbbiiiinnnnddddiiiinnnngggg????

      In deep binding, lexical variables mentioned in anonymous
      subroutines are the same ones    that were in scope when    the
      subroutine was created.  In shallow binding, they are
      whichever variables with the same names happen to be in
      scope    when the subroutine is called.    Perl always uses deep
      binding of lexical variables (i.e., those created with
      _m_y()).  However, dynamic variables (aka global, local, or
      package variables) are effectively shallowly bound.
      Consider this    just one more reason not to use    them.  See the
      answer to the    section    on _W_h_a_t'_s _a _c_l_o_s_u_r_e?.

      WWWWhhhhyyyy ddddooooeeeessssnnnn''''tttt """"_m_y($foo)    = <FILE>;" work    right?

      my() and local() give    list context to    the right hand side of
      =.  The <FH> read operation, like so many of Perl's



     Page 12                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      functions and    operators, can tell which context it was
      called in and    behaves    appropriately.    In general, the
      _s_c_a_l_a_r() function can    help.  This function does nothing to
      the data itself (contrary to popular myth) but rather    tells
      its argument to behave in whatever its scalar    fashion    is.
      If that function doesn't have    a defined scalar behavior,
      this of course doesn't help you (such    as with    _s_o_r_t()).

      To enforce scalar context in this particular case, however,
      you need merely omit the parentheses:

          local($foo) = <FILE>;          #    WRONG
          local($foo) = scalar(<FILE>);   #    ok
          local $foo  = <FILE>;          #    right

      You should probably be using lexical variables anyway,
      although the issue is    the same here:

          my($foo) = <FILE>;  # WRONG
          my $foo  = <FILE>;  # right


      HHHHoooowwww ddddoooo IIII rrrreeeeddddeeeeffffiiiinnnneeee aaaa bbbbuuuuiiiillllttttiiiinnnn ffffuuuunnnnccccttttiiiioooonnnn,,,,    ooooppppeeeerrrraaaattttoooorrrr,,,, oooorrrr mmmmeeeetttthhhhoooodddd????

      Why do you want to do    that? :-)

      If you want to override a predefined function, such as
      _o_p_e_n(), then you'll have to import the new definition    from a
      different module.  See the section on    _O_v_e_r_r_i_d_i_n_g _B_u_i_l_t_i_n
      _F_u_n_c_t_i_o_n_s in the _p_e_r_l_s_u_b manpage.  There's also an example
      in the section on _C_l_a_s_s::_T_e_m_p_l_a_t_e in the _p_e_r_l_t_o_o_t manpage.

      If you want to overload a Perl operator, such    as + or    **,
      then you'll want to use the use overload pragma, documented
      in the _o_v_e_r_l_o_a_d manpage.

      If you're talking about obscuring method calls in parent
      classes, see the section on _O_v_e_r_r_i_d_d_e_n _M_e_t_h_o_d_s in the
      _p_e_r_l_t_o_o_t manpage.

      WWWWhhhhaaaatttt''''ssss tttthhhheeee ddddiiiiffffffffeeeerrrreeeennnncccceeee    bbbbeeeettttwwwweeeeeeeennnn    ccccaaaalllllllliiiinnnngggg    aaaa ffffuuuunnnnccccttttiiiioooonnnn aaaassss &&&&ffffoooooooo aaaannnndddd
      _f_o_o()?

      When you call    a function as &foo, you    allow that function
      access to your current @_ values, and    you by-pass
      prototypes.  That means that the function doesn't get    an
      empty    @_, it gets yours!  While not strictly speaking    a bug
      (it's    documented that    way in the _p_e_r_l_s_u_b manpage), it    would
      be hard to consider this a feature in    most cases.

      When you call    your function as &foo(), then you _d_o get a new
      @_, but prototyping is still circumvented.



     Page 13                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      Normally, you    want to    call a function    using foo().  You may
      only omit the    parentheses if the function is already known
      to the compiler because it already saw the definition    (use
      but not require), or via a forward reference or use subs
      declaration.    Even in    this case, you get a clean @_ without
      any of the old values    leaking    through    where they don't
      belong.

      HHHHoooowwww ddddoooo IIII ccccrrrreeeeaaaatttteeee aaaa sssswwwwiiiittttcccchhhh oooorrrr ccccaaaasssseeee ssssttttaaaatttteeeemmmmeeeennnntttt????

      This is explained in more depth in the the _p_e_r_l_s_y_n manpage.
      Briefly, there's no official case statement, because of the
      variety of tests possible in Perl (numeric comparison,
      string comparison, glob comparison, regexp matching,
      overloaded comparisons, ...).     Larry couldn't    decide how
      best to do this, so he left it out, even though it's been on
      the wish list    since perl1.

      The general answer is    to write a construct like this:

          for ($variable_to_test) {
          if    (/pat1/)  { }      # do something
          elsif    (/pat2/)  { }      # do something else
          elsif    (/pat3/)  { }      # do something else
          else          { }      # default
          }

      Here's a simple example of a switch based on pattern
      matching, this time lined up in a way    to make    it look    more
      like a switch    statement.  We'll do a multi-way conditional
      based    on the type of reference stored    in $whatchamacallit:

          SWITCH: for (ref $whatchamacallit) {

          /^$/          && die "not a    reference";

          /SCALAR/      && do    {
                      print_scalar($$ref);
                      last SWITCH;
                  };

          /ARRAY/      && do    {
                      print_array(@$ref);
                      last SWITCH;
                  };

          /HASH/      && do    {
                      print_hash(%$ref);
                      last SWITCH;
                  };





     Page 14                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



          /CODE/      && do    {
                      warn "can't print function ref";
                      last SWITCH;
                  };

          # DEFAULT

          warn "User defined type skipped";

          }

      See perlsyn/"Basic BLOCKs and    Switch Statements" for many
      other    examples in this style.

      Sometimes you    should change the positions of the constant
      and the variable.  For example, let's    say you    wanted to test
      which    of many    answers    you were given,    but in a case-
      insensitive way that also allows abbreviations.  You can use
      the following    technique if the strings all start with
      different characters,    or if you want to arrange the matches
      so that one takes precedence over another, as    "SEND" has
      precedence over "STOP" here:

          chomp($answer = <>);
          if    ("SEND"  =~    /^\Q$answer/i) { print "Action is send\n"  }
          elsif ("STOP"  =~    /^\Q$answer/i) { print "Action is stop\n"  }
          elsif ("ABORT" =~    /^\Q$answer/i) { print "Action is abort\n" }
          elsif ("LIST"  =~    /^\Q$answer/i) { print "Action is list\n"  }
          elsif ("EDIT"  =~    /^\Q$answer/i) { print "Action is edit\n"  }

      A totally different approach is to create a hash of function
      references.

          my %commands = (
          "happy" => \&joy,
          "sad",  => \&sullen,
          "done"  => sub { die "See ya!" },
          "mad"      => \&angry,
          );

          print "How are you? ";
          chomp($string = <STDIN>);
          if ($commands{$string}) {
          $commands{$string}->();
          }    else {
          print    "No such command: $string\n";
          }








     Page 15                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      HHHHoooowwww ccccaaaannnn IIII ccccaaaattttcccchhhh aaaacccccccceeeesssssssseeeessss ttttoooo uuuunnnnddddeeeeffffiiiinnnneeeedddd
      vvvvaaaarrrriiiiaaaabbbblllleeeessss////ffffuuuunnnnccccttttiiiioooonnnnssss////mmmmeeeetttthhhhooooddddssss????

      The AUTOLOAD method, discussed in the    section    on _A_u_t_o_l_o_a_d_i_n_g
      in the _p_e_r_l_s_u_b manpage and the section on _A_U_T_O_L_O_A_D: _P_r_o_x_y
      _M_e_t_h_o_d_s in the _p_e_r_l_t_o_o_t manpage, lets    you capture calls to
      undefined functions and methods.

      When it comes    to undefined variables that would trigger a
      warning under    -w, you    can use    a handler to trap the pseudo-
      signal __WARN__ like this:

          $SIG{__WARN__} = sub {

          for (    $_[0] )    {      # voici un switch statement

              /Use of uninitialized value/  && do {
              # promote warning to a fatal
              die $_;
              };

              #    other warning cases to catch could go here;

              warn $_;
          }

          };


      WWWWhhhhyyyy ccccaaaannnn''''tttt aaaa mmmmeeeetttthhhhoooodddd iiiinnnncccclllluuuuddddeeeedddd iiiinnnn tttthhhhiiiissss ssssaaaammmmeeee ffffiiiilllleeee    bbbbeeee ffffoooouuuunnnndddd????

      Some possible    reasons: your inheritance is getting confused,
      you've misspelled the    method name, or    the object is of the
      wrong    type.  Check out the _p_e_r_l_t_o_o_t manpage for details on
      these.  You may also use print ref($object) to find out the
      class    $object    was blessed into.

      Another possible reason for problems is because you've used
      the indirect object syntax (eg, find Guru "Samy") on a class
      name before Perl has seen that such a    package    exists.     It's
      wisest to make sure your packages are    all defined before you
      start    using them, which will be taken    care of    if you use the
      use statement    instead    of require.  If    not, make sure to use
      arrow    notation (eg, Guru->find("Samy")) instead.  Object
      notation is explained    in the _p_e_r_l_o_b_j manpage.

      Make sure to read about creating modules in the _p_e_r_l_m_o_d
      manpage and the perils of indirect objects in    the section on
      _W_A_R_N_I_N_G in the _p_e_r_l_o_b_j manpage.






     Page 16                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      HHHHoooowwww ccccaaaannnn IIII ffffiiiinnnndddd oooouuuutttt mmmmyyyy    ccccuuuurrrrrrrreeeennnntttt    ppppaaaacccckkkkaaaaggggeeee????

      If you're just a random program, you can do this to find out
      what the currently compiled package is:

          my $packname = __PACKAGE__;

      But if you're    a method and you want to print an error
      message that includes    the kind of object you were called on
      (which is not    necessarily the    same as    the one    in which you
      were compiled):

          sub amethod {
          my $self  = shift;
          my $class = ref($self) || $self;
          warn "called me from a $class    object";
          }


      HHHHoooowwww ccccaaaannnn IIII ccccoooommmmmmmmeeeennnntttt oooouuuutttt    aaaa llllaaaarrrrggggeeee    bbbblllloooocccckkkk ooooffff ppppeeeerrrrllll ccccooooddddeeee????

      Use embedded POD to discard it:

          #    program    is here

          =for nobody
          This paragraph is    commented out

          #    program    continues

          =begin comment text

          all of this stuff

          here will    be ignored
          by everyone

          =end comment text

          =cut

      This can't go    just anywhere.    You have to put    a pod
      directive where the parser is    expecting a new    statement, not
      just in the middle of    an expression or some other arbitrary
      yacc grammar production.

     AAAAUUUUTTTTHHHHOOOORRRR AAAANNNNDDDD    CCCCOOOOPPPPYYYYRRRRIIIIGGGGHHHHTTTT
      Copyright (c)    1997, 1998 Tom Christiansen and    Nathan
      Torkington.  All rights reserved.

      When included    as part    of the Standard    Version    of Perl, or as
      part of its complete documentation whether printed or



     Page 17                        (printed 10/23/98)






     PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))     22223333////JJJJuuuullll////99998888 ((((ppppeeeerrrrllll 5555....000000005555,,,, ppppaaaattttcccchhhh 00002222))))       PPPPEEEERRRRLLLLFFFFAAAAQQQQ7777((((1111))))



      otherwise, this work may be distributed only under the terms
      of Perl's Artistic License.  Any distribution    of this    file
      or derivatives thereof _o_u_t_s_i_d_e of that package require that
      special arrangements be made with copyright holder.

      Irrespective of its distribution, all    code examples in this
      file are hereby placed into the public domain.  You are
      permitted and    encouraged to use this code in your own
      programs for fun or for profit as you    see fit.  A simple
      comment in the code giving credit would be courteous but is
      not required.












































     Page 18                        (printed 10/23/98)